home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 0.9.1.3 stable / flock-0.9.1.3.en-US.win32.exe / flock / chrome / browser.jar / content / browser / preferences / advanced.js < prev    next >
Text File  |  2007-07-13  |  14KB  |  412 lines
  1. //@line 39 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/preferences/advanced.js"
  2.  
  3. var gAdvancedPane = {
  4.   _inited: false,
  5.  
  6.   /**
  7.    * Brings the appropriate tab to the front and initializes various bits of UI.
  8.    */
  9.   init: function ()
  10.   {
  11.     this._inited = true;
  12.     var advancedPrefs = document.getElementById("advancedPrefs");
  13.     var preference = document.getElementById("browser.preferences.advanced.selectedTabIndex");
  14.     if (preference.value === null)
  15.       return;
  16.     advancedPrefs.selectedIndex = preference.value;
  17.  
  18.     this.updateAppUpdateItems();
  19.     this.updateAutoItems();
  20.     this.updateModeItems();
  21.   },
  22.  
  23.   /**
  24.    * Stores the identity of the current tab in preferences so that the selected
  25.    * tab can be persisted between openings of the preferences window.
  26.    */
  27.   tabSelectionChanged: function ()
  28.   {
  29.     if (!this._inited)
  30.       return;
  31.     var advancedPrefs = document.getElementById("advancedPrefs");
  32.     var preference = document.getElementById("browser.preferences.advanced.selectedTabIndex");
  33.     preference.valueFromPreferences = advancedPrefs.selectedIndex;
  34.   },
  35.  
  36.   // GENERAL TAB
  37.  
  38.   /*
  39.    * Preferences:
  40.    *
  41.    * accessibility.browsewithcaret
  42.    * - true enables keyboard navigation and selection within web pages using a
  43.    *   visible caret, false uses normal keyboard navigation with no caret
  44.    * accessibility.typeaheadfind
  45.    * - when set to true, typing outside text areas and input boxes will
  46.    *   automatically start searching for what's typed within the current
  47.    *   document; when set to false, no search action happens
  48.    * general.autoScroll
  49.    * - when set to true, clicking the scroll wheel on the mouse activates a
  50.    *   mouse mode where moving the mouse down scrolls the document downward with
  51.    *   speed correlated with the distance of the cursor from the original
  52.    *   position at which the click occurred (and likewise with movement upward);
  53.    *   if false, this behavior is disabled
  54.    * general.smoothScroll
  55.    * - set to true to enable finer page scrolling than line-by-line on page-up,
  56.    *   page-down, and other such page movements
  57.    * layout.spellcheckDefault
  58.    * - an integer:
  59.    *     0  disables spellchecking
  60.    *     1  enables spellchecking, but only for multiline text fields
  61.    *     2  enables spellchecking for all text fields
  62.    */
  63.  
  64.   /**
  65.    * Stores the original value of the spellchecking preference to enable proper
  66.    * restoration if unchanged (since we're mapping a tristate onto a checkbox).
  67.    */
  68.   _storedSpellCheck: 0,
  69.  
  70.   /**
  71.    * Returns true if any spellchecking is enabled and false otherwise, caching
  72.    * the current value to enable proper pref restoration if the checkbox is
  73.    * never changed.
  74.    */
  75.   readCheckSpelling: function ()
  76.   {
  77.     var pref = document.getElementById("layout.spellcheckDefault");
  78.     this._storedSpellCheck = pref.value;
  79.  
  80.     return (pref.value != 0);
  81.   },
  82.  
  83.   /**
  84.    * Returns the value of the spellchecking preference represented by UI,
  85.    * preserving the preference's "hidden" value if the preference is
  86.    * unchanged and represents a value not strictly allowed in UI.
  87.    */
  88.   writeCheckSpelling: function ()
  89.   {
  90.     var checkbox = document.getElementById("checkSpelling");
  91.     return checkbox.checked ? (this._storedSpellCheck == 2 ? 2 : 1) : 0;
  92.   },
  93.  
  94.   /**
  95.    * Shows a dialog in which the preferred language for web content may be set.
  96.    */
  97.   showLanguages: function ()
  98.   {
  99.     document.documentElement.openSubDialog("chrome://browser/content/preferences/languages.xul",
  100.                                            "", null);
  101.   },
  102.  
  103.   // NETWORK TAB
  104.  
  105.   /*
  106.    * Preferences:
  107.    *
  108.    * browser.cache.disk.capacity
  109.    * - the size of the browser cache in KB
  110.    */
  111.  
  112.   /**
  113.    * Displays a dialog in which proxy settings may be changed.
  114.    */
  115.   showConnections: function ()
  116.   {
  117.     document.documentElement.openSubDialog("chrome://browser/content/preferences/connection.xul",
  118.                                            "", null);
  119.   },
  120.  
  121.   /**
  122.    * Converts the cache size from units of KB to units of MB and returns that
  123.    * value.
  124.    */
  125.   readCacheSize: function ()
  126.   {
  127.     var preference = document.getElementById("browser.cache.disk.capacity");
  128.     return preference.value / 1000;
  129.   },
  130.  
  131.   /**
  132.    * Converts the cache size as specified in UI (in MB) to KB and returns that
  133.    * value.
  134.    */
  135.   writeCacheSize: function ()
  136.   {
  137.     var cacheSize = document.getElementById("cacheSize");
  138.     var intValue = parseInt(cacheSize.value, 10);
  139.     return isNaN(intValue) ? 0 : intValue * 1000;
  140.   },
  141.  
  142.   /**
  143.    * Clears the cache.
  144.    */
  145.   clearCache: function ()
  146.   {
  147.     var cacheService = Components.classes["@mozilla.org/network/cache-service;1"]
  148.                                     .getService(Components.interfaces.nsICacheService);
  149.     try {
  150.       cacheService.evictEntries(Components.interfaces.nsICache.STORE_ANYWHERE);
  151.     } catch(ex) {}
  152.   },
  153.  
  154.   // UPDATE TAB
  155.  
  156.   /*
  157.    * Preferences:
  158.    *
  159.    * app.update.enabled
  160.    * - true if updates to the application are enabled, false otherwise
  161.    * extensions.update.enabled
  162.    * - true if updates to extensions and themes are enabled, false otherwise
  163.    * browser.search.update
  164.    * - true if updates to search engines are enabled, false otherwise
  165.    * app.update.auto
  166.    * - true if updates should be automatically downloaded and installed,
  167.    *   possibly with a warning if incompatible extensions are installed (see
  168.    *   app.update.mode); false if the user should be asked what he wants to do
  169.    *   when an update is available
  170.    * app.update.mode
  171.    * - an integer:
  172.    *     0    do not warn if an update will disable extensions or themes
  173.    *     1    warn if an update will disable extensions or themes
  174.    *     2    warn if an update will disable extensions or themes *or* if the
  175.    *          update is a major update
  176.    */
  177.  
  178.   /**
  179.    * Enables and disables various UI preferences as necessary to reflect locked,
  180.    * disabled, and checked/unchecked states.
  181.    *
  182.    * UI state matrix for update preference conditions
  183.    *
  184.    * UI Components:                                     Preferences
  185.    * 1 = Firefox checkbox                               i   = app.update.enabled
  186.    * 2 = When updates for Firefox are found label       ii  = app.update.auto
  187.    * 3 = Automatic Radiogroup (Ask vs. Automatically)   iii = app.update.mode
  188.    * 4 = Warn before disabling extensions checkbox
  189.    *
  190.    * States:
  191.    * Element     p   val     locked    Disabled
  192.    * 1           i   t/f     f         false
  193.    *             i   t/f     t         true
  194.    *             ii  t/f     t/f       false
  195.    *             iii 0/1/2   t/f       false
  196.    * 2,3         i   t       t/f       false
  197.    *             i   f       t/f       true
  198.    *             ii  t/f     f         false
  199.    *             ii  t/f     t         true
  200.    *             iii 0/1/2   t/f       false
  201.    * 4           i   t       t/f       false
  202.    *             i   f       t/f       true
  203.    *             ii  t       t/f       false
  204.    *             ii  f       t/f       true
  205.    *             iii 0/1/2   f         false
  206.    *             iii 0/1/2   t         true
  207.    *
  208.    */
  209.   updateAppUpdateItems: function ()
  210.   {
  211.     var aus =
  212.         Components.classes["@mozilla.org/updates/update-service;1"].
  213.         getService(Components.interfaces.nsIApplicationUpdateService);
  214.  
  215.     var enabledPref = document.getElementById("app.update.enabled");
  216.     var enableAppUpdate = document.getElementById("enableAppUpdate");
  217.  
  218.     enableAppUpdate.disabled = !aus.canUpdate || enabledPref.locked;
  219.   },
  220.  
  221.   /**
  222.    * Enables/disables UI for "when updates are found" based on the values,
  223.    * and "locked" states of associated preferences.
  224.    */
  225.   updateAutoItems: function ()
  226.   {
  227.     var enabledPref = document.getElementById("app.update.enabled");
  228.     var autoPref = document.getElementById("app.update.auto");
  229.  
  230.     var updateModeLabel = document.getElementById("updateModeLabel");
  231.     var updateMode = document.getElementById("updateMode");
  232.  
  233.     var disable = enabledPref.locked || !enabledPref.value ||
  234.                   autoPref.locked;
  235.     updateModeLabel.disabled = updateMode.disabled = disable;
  236.   },
  237.  
  238.   /**
  239.    * Enables/disables the "warn if incompatible extensions/themes exist" UI
  240.    * based on the values and "locked" states of various preferences.
  241.    */
  242.   updateModeItems: function ()
  243.   {
  244.     var enabledPref = document.getElementById("app.update.enabled");
  245.     var autoPref = document.getElementById("app.update.auto");
  246.     var modePref = document.getElementById("app.update.mode");
  247.  
  248.     var warnIncompatible = document.getElementById("warnIncompatible");
  249.  
  250.     var disable = enabledPref.locked || !enabledPref.value || autoPref.locked ||
  251.                   !autoPref.value || modePref.locked;
  252.     warnIncompatible.disabled = disable;
  253.   },
  254.  
  255.   /**
  256.    * The Extensions checkbox and button are disabled only if the enable Addon
  257.    * update preference is locked.
  258.    */
  259.   updateAddonUpdateUI: function ()
  260.   {
  261.     var enabledPref = document.getElementById("extensions.update.enabled");
  262.     var enableAddonUpdate = document.getElementById("enableAddonUpdate");
  263.  
  264.     enableAddonUpdate.disabled = enabledPref.locked;
  265.   },
  266.  
  267.   /**
  268.    * Stores the value of the app.update.mode preference, which is a tristate
  269.    * integer preference.  We store the value here so that we can properly
  270.    * restore the preference value if the UI reflecting the preference value
  271.    * is in a state which can represent either of two integer values (as
  272.    * opposed to only one possible value in the other UI state).
  273.    */
  274.   _modePreference: -1,
  275.  
  276.   /**
  277.    * Reads the app.update.mode preference and converts its value into a
  278.    * true/false value for use in determining whether the "Warn me if this will
  279.    * disable extensions or themes" checkbox is checked.  We also save the value
  280.    * of the preference so that the preference value can be properly restored if
  281.    * the user's preferences cannot adequately be expressed by a single checkbox.
  282.    *
  283.    * app.update.modee         Checkbox State    Meaning
  284.    * 0                        Unchecked         Do not warn
  285.    * 1                        Checked           Warn if there are incompatibilities
  286.    * 2                        Checked           Warn if there are incompatibilities,
  287.    *                                            or the update is major.
  288.    */
  289.   readAddonWarn: function ()
  290.   {
  291.     var preference = document.getElementById("app.update.mode");
  292.     var doNotWarn = preference.value != 0;
  293.     gAdvancedPane._modePreference = doNotWarn ? preference.value : 1;
  294.     return doNotWarn;
  295.   },
  296.  
  297.   /**
  298.    * Converts the state of the "Warn me if this will disable extensions or
  299.    * themes" checkbox into the integer preference which represents it,
  300.    * returning that value.
  301.    */
  302.   writeAddonWarn: function ()
  303.   {
  304.     var warnIncompatible = document.getElementById("warnIncompatible");
  305.     return !warnIncompatible.checked ? 0 : gAdvancedPane._modePreference;
  306.   },
  307.  
  308.   /**
  309.    * Displays the history of installed updates.
  310.    */
  311.   showUpdates: function ()
  312.   {
  313.     var prompter = Components.classes["@mozilla.org/updates/update-prompt;1"]
  314.                              .createInstance(Components.interfaces.nsIUpdatePrompt);
  315.     prompter.showUpdateHistory(window);
  316.   },
  317.  
  318.   // FLOCK : Stevo - Helper function for forcing service updates.
  319.   /**
  320.    * Forces an update of the service xml files for WebDetective.
  321.    *
  322.    * LOCALIZE ME! - The serviceStatus.value assignements need to be localized.
  323.    */
  324.   forceServiceUpdates: function()
  325.   {
  326.     var serviceStatus = document.getElementById("serviceUpdateStatus");
  327.     var forceServiceUpdatesButton = document.getElementById("forceServiceUpdates");
  328.  
  329.     if (serviceStatus) {
  330.       serviceStatus.value = "Starting service update.";
  331.     }
  332.  
  333.     var serviceUpdateCallBack = {
  334.       onStart : function(aSubject, aTopic) {
  335.         serviceStatus.value = "Updating service " + aTopic;
  336.       },
  337.       onSuccess : function(aSubject, aTopic) {
  338.         serviceStatus.value = "Service Update Completed Successfully.";
  339.         forceServiceUpdatesButton.disabled = false;
  340.       },
  341.       onError : function(aSubject, aTopic, aError) {
  342.         serviceStatus.value = "Service Update Failed.";
  343.         forceServiceUpdatesButton.disabled = false;
  344.       }
  345.     };
  346.  
  347.     var webDetective = Components.classes["@flock.com/web-detective;1"]
  348.                                   .getService(Components.interfaces.flockIWebDetective);
  349.     if (webDetective) {
  350.       forceServiceUpdatesButton.disabled = true;
  351.       webDetective.checkForUpdates(true, serviceUpdateCallBack);
  352.     }
  353.   },
  354.  
  355.   // ENCRYPTION TAB
  356.  
  357.   /*
  358.    * Preferences:
  359.    *
  360.    * security.enable_ssl3
  361.    * - true if SSL 3 encryption is enabled, false otherwise
  362.    * security.enable_tls
  363.    * - true if TLS encryption is enabled, false otherwise
  364.    * security.default_personal_cert
  365.    * - a string:
  366.    *     "Select Automatically"   select a certificate automatically when a site
  367.    *                              requests one
  368.    *     "Ask Every Time"         present a dialog to the user so he can select
  369.    *                              the certificate to use on a site which
  370.    *                              requests one
  371.    */
  372.  
  373.   /**
  374.    * Displays the user's certificates and associated options.
  375.    */
  376.   showCertificates: function ()
  377.   {
  378.     document.documentElement.openWindow("mozilla:certmanager",
  379.                                         "chrome://pippki/content/certManager.xul",
  380.                                         "", null);
  381.   },
  382.  
  383.   /**
  384.    * Displays a dialog which describes the user's CRLs.
  385.    */
  386.   showCRLs: function ()
  387.   {
  388.     document.documentElement.openWindow("Mozilla:CRLManager",
  389.                                         "chrome://pippki/content/crlManager.xul",
  390.                                         "", null);
  391.   },
  392.  
  393.   /**
  394.    * Displays a dialog in which OCSP preferences can be configured.
  395.    */
  396.   showOCSP: function ()
  397.   {
  398.     document.documentElement.openSubDialog("chrome://mozapps/content/preferences/ocsp.xul",
  399.                                            "", null);
  400.   },
  401.  
  402.   /**
  403.    * Displays a dialog from which the user can manage his security devices.
  404.    */
  405.   showSecurityDevices: function ()
  406.   {
  407.     document.documentElement.openWindow("mozilla:devicemanager",
  408.                                         "chrome://pippki/content/device_manager.xul",
  409.                                         "", null);
  410.   }
  411. };
  412.